﻿#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;
//class Date
//{
//public:
//	//Date()  //无参构造函数
//	//{
//	//	cout << "Date()" << endl;
//	//}
//	//Date(int year, int month, int day)  //有参数的构造函数；此时和无参构造函数是函数重载关系
//	//{
//	//	cout << "Date(int year, int month, int day)" << endl;
//	//	_year = year;
//	//	_month = month;
//	//	_day = day;
//	//}
//	
	//Date(int year = 2024, int month = 8, int day=1) //全缺省构造函数
	//{
	//	cout << "Date(int year = 2024,int month = 8, int day=1)" << endl;
	//	_year = year;
	//	_month = month;
	//	_day = day;
	//}
//	//构造函数也是成员函数；在代码公共区域存放
//	
//	//对于编译器而言：当用户自己不写构造函数；编译器会自动生成构造函数
//	
//	//无参构造函数；全缺省构造函数；编译器默认生成的构造函数 都是默认的构造函数
//	// 默认构造函数的使用：实例化的时候不需要传参
//	void Print()
//	{
//		cout << _year << '/' << _month << '/' << _day << endl;
//	}
//private:
//	//以下只是成员的声明，并不是初始化（开空间）
//	int _year = 1;//给一个缺省值
//	int _month = 1;
//	int _day = 1;
//};

//int main()
//{
//	//Date d1;//实例化的同时自动调用构造函数;此时调用无参
//	//d1.Print();//打印的是随机值    ？ 构造函数对于内置类型的成员不做处理（随机值）；对于自定义类型的 成员 会去调用 此成员 的构造函数
//	////针对无参构造函数的问题对应解决：在声明成员的同时给一个缺省值
//	//Date d2(2024, 8, 2);//调用有参
//	//d2.Print();
//	// 总结
//	// 当成员是内置类型的时候，对于构造函数一般使用全缺省的构造函数
//	//一般都是自己写构造函数，来决定初始化方式
//	Date d1(2024, 7, 31);
//	d1.Print();
//
//	return 0;
//}
class Date
{
public:
	int _year;
	int _month;
	int _day;
	void Print()
	{
		cout << _year << '/' << _month << '/' << _day << endl;
	}
	Date(int year = 2024, int month = 3, int day = 26)//全缺省的构造函数（对于内置类型不做处理，对于自定义类型做处理）
	{
		_year = year;
		_month = month;
		_day = day;
	}
	//注意对于Date这个类不需要写拷贝构造函数，编译器可以进行处理
	Date(const Date& d)//拷贝构造函数（对应内置类型是做浅层拷贝，自定义类型深层拷贝）
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	// d1 > d2 *this 默认指向运算符的左操数，此时d是d2的引用
	bool operator>(const Date& d)
	{
		if (_year > d._year)
		{
			return true;
		}
		else if (_year == d._year && _month > d._month)
		{
			return  true;
		}
		else if (_year == d._year && _month == d._month && _day > d._day)
		{
			return true;
		}
		else
			return false;
	}
	// d1 == d2
	bool operator==(const Date& d)
	{
		return _year == d._year && _month == d._month && _day == d._day;
	}
	bool operator!=(const Date& d)
	{
		//直接复用之前代码
		return !(*this == d);
	}
	//d1 >= d2 ===> d1 > d2 || d1 == d2
	bool operator>=(const Date& d)
	{
		return(((*this) > d) || (*this) == d);
	}
	// d1 <= d2
	bool operator<= (const Date& d)
	{
		//对 . 进行取反
		return !(*this > d);
	}
};
int main()
{
	Date d1(2024, 11, 26);//调用构造函数进行实例化
	Date d2;// 只不过是用全缺省函数进行初始化
	cout << (d1 <= d2) << endl;//编译器会自动转换成调用这个!= 运算符重载函数 d1.operator(d2)

	return 0;
}
class Stack
{
public:
	Stack(int n = 0)
	{
		cout << "Stack()" << endl;
		if (n == 0)
		{
			//默认开4个空间
			int* tmp = (int*)malloc(sizeof(int) * 4);
			if(tmp == nullptr)
			{
				perror("Stack()::malloc");
				return;
			}
			_a = tmp;
			_capacity = n;
		}
		else
		{
			//根据需求开空间
			int* tmp = (int*)malloc(sizeof(int) * n);
			if (tmp == nullptr)
			{
				perror("Stack()::malloc");
				return;
			}
			_a = tmp;
			_capacity = n;
		}
		_top = 0;//指向栈顶元素下一个位置
	}
	~Stack()
	{
		//完成资源清理；注意不是进行对象销毁
		cout << "~Stack()" << endl;
		free(_a);
		_a = nullptr;
		_top = _capacity = 0;
	}
	Stack(const Stack& st)
	{
		cout<<"Stack(const Stack & st)" << endl;
		//…… 空间开辟，数据拷贝，原空间释放
	}
private:
	int* _a;
	int _top;
	int _capacity;
};
class MyQueue
{
private:
	Stack _PopSt;
	Stack _PushSt;
};
int main()
{
	//此时 mq 直接用现成的就OK
	//mq构造函数，析构函数,拷贝构造函数都是调用自定义类型成员的构造，析构，拷贝构造函数
	MyQueue mq;
	MyQueue mq1 = mq;
	//Stack st1;
	//Stack st2 = st1;//对象st2  是st1的拷贝
	

	return 0;
}
//#include<stdio.h>
//#define MAX(x,y) ((x)>(y)? (x):(y))
//int main()
//{
//	/*
//	int a = 0;
//	printf("%d\n", a);
//	return 0;*/
//	int a = 2;
//	int b = 4;
//	int ret = DOUBLE(a | b);
//	//此时会被替换成 （a|b + a|b ）
//	//注意 + 优先级高于 |
//	//所以会先执行 b + a
//	//这样就改变了与自己想要的结果了
//	/*
//	1. 在调用宏时，首先对参数进行检查，看看是否包含任何由#define定义的符号。如果是，它们首先被替换。
//    2. 替换文本随后被插入到程序中原来文本的位置。对于宏，参数名被他们的值所替换。
//    3. 最后，再次对结果文件进行扫描，看看它是否包含任何由#define定义的符号。如果是，就重复上 述处理过程。
//	*/
//	printf("%d\n", ret);
//
//}
//int Max(int x, int y)
//{
//	return x > y ? x : y;
//}
//int main()
//{
//	int a = 2;
//	int b = 3;
//	int ret = MAX(a++, b++);
//	
//	printf("ret = %d  a=%d  b= %d ",ret, a, b);
//	//注意后置++规则：先使用 再进行++
//    //#define MAX(x,y)                              ((x)>(y)? (x):(y))
//	//(2++,3++)此时传给后面表达式的时候是++之后的 ==》 ((3)>(4)? (x):(4++)) 此时y=4是大的，执行后面表达式
//	//                                                      x=3  y=4   
//	//   a = x = 3    b = y = 4
//	return 0;
//}
//class Date
//{
//public:
//	Date()
//	{
//		cout << "Date()" << endl;
//
//	}
//	~Date()
//	{
//		cout << "~Date()" << endl;
//	}
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//int main()
//{
//	Date d1;
//	Stack st1;
//	return 0;
//}
/*
在函数F中，本地变量a和b的构造函数(constructor)和析构函数(destructor)的调用顺序是: ( )

﻿Class A;

Class B;

void F() 
{

	A a;

  B b;

  }
*/